<html>
 <head>
  <meta charset="UTF-8">
 </head>
 <body>
  <p data-lake-id="u818440aa" id="u818440aa"><span data-lake-id="u0ba8f874" id="u0ba8f874">在并发编程的世界里，共享变量的线程安全问题永远是一个无法避免且不得不面对的问题，如果只有读的情况，那么永远也不会出现线程安全的问题，因为多线程读永远是线程安全的，但是多线程读写一定会存在线程安全的问题。</span></p>
  <p data-lake-id="u707cb862" id="u707cb862"><br></p>
  <p data-lake-id="uf9538288" id="uf9538288"><span data-lake-id="u29060dc3" id="u29060dc3">那既然这么说是不是通过只读就能解决并发问题呢？其实最简单的办法就是让共享变量只有读操作，而没有写操作。这个办法如此重要，以至于被上升到了一种解决并发问题的设计模式：</span><strong><span data-lake-id="u9346e01c" id="u9346e01c">不变性（Immutability）模式</span></strong><span data-lake-id="udfeb3046" id="udfeb3046">。</span></p>
  <p data-lake-id="u8ff1ce27" id="u8ff1ce27"><br></p>
  <p data-lake-id="uc8e3fe68" id="uc8e3fe68"><span data-lake-id="u8629e7ad" id="u8629e7ad">所谓不变性，简单来讲，就是对象一旦被创建之后，状态就不再发生变化。换句话说，就是变量一旦被赋值，就不允许修改了（没有写操作）；没有修改操作，也就是保持了不变性。</span></p>
  <p data-lake-id="ueac8b8ac" id="ueac8b8ac"><br></p>
  <h2 data-lake-id="e7584114" id="e7584114"><span data-lake-id="u70cb6791" id="u70cb6791">不可变性的类</span></h2>
  <p data-lake-id="u63ed28b5" id="u63ed28b5"><br></p>
  <p data-lake-id="u47a4d998" id="u47a4d998"><span data-lake-id="u2ac6b396" id="u2ac6b396">在 java 中，如果要实现一个不可变的对象是很简单的，将其定义为 final 即可，同样类也是如此，只需要通过 final 来修饰某个类即可。同时将一个类所有的属性都设置成 final 的，并且只允许存在只读方法，那么这个类基本上就具备不可变性了。</span></p>
  <p data-lake-id="uea8b3d51" id="uea8b3d51"><br></p>
  <p data-lake-id="u68754930" id="u68754930"><span data-lake-id="u3ca2f3b6" id="u3ca2f3b6">更严格的做法是这个类本身也是 final 的，也就是不允许继承。因为子类可以覆盖父类的方法，有可能改变不可变性，所以推荐你在实际工作中，使用这种更严格的做法。</span></p>
  <p data-lake-id="u8154237d" id="u8154237d"><br></p>
  <p data-lake-id="u47e4c3a6" id="u47e4c3a6"><span data-lake-id="u42293eb0" id="u42293eb0">我们再日常开发中，已经在不知不觉中享受不可变模式带来的好处，例如经常用到的 </span><code data-lake-id="ud9c0078c" id="ud9c0078c"><span data-lake-id="u6b089108" id="u6b089108">String、Long、Integer、Double</span></code><span data-lake-id="ue42e11f8" id="ue42e11f8"> 等基础类型的包装类都具备不可变性，这些对象的线程安全性都是靠不可变性来保证的。</span></p>
  <p data-lake-id="udd02d4c7" id="udd02d4c7"><br></p>
  <p data-lake-id="u178d4cf7" id="u178d4cf7"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331165502.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_21%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="uaea7270c" id="uaea7270c"><br></p>
  <p data-lake-id="ua05b9b3d" id="ua05b9b3d"><span data-lake-id="ud8e7f56f" id="ud8e7f56f">仔细翻看这些类的声明、属性和方法，你会发现它们都严格遵守不可变类的三点要求：类是 final 的，属性也是 final 的。同样的一旦某个类被 final 修饰，其本身就不能被继承了，也就无法重写其方法，即方法是只读的。</span></p>
  <p data-lake-id="uacd39efb" id="uacd39efb"><br></p>
  <p data-lake-id="u8f7f3c90" id="u8f7f3c90"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331165343.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_20%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="uc149d29e" id="uc149d29e"><br></p>
  <p data-lake-id="ue9740aee" id="ue9740aee"><span data-lake-id="u8f8f6504" id="u8f8f6504">既然说方法是只读的，但是 Java 的 String 方法也有类似字符替换操作，这个不就已经改变了value[] 变量了吗？因为 value[] 是这么定义的。</span></p>
  <p data-lake-id="u10fc0013" id="u10fc0013"><br></p>
  <p data-lake-id="u9fb97a1a" id="u9fb97a1a"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331165743.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_15%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="u5e0e148f" id="u5e0e148f"><br></p>
  <p data-lake-id="u1727fe65" id="u1727fe65"><span data-lake-id="ub694da54" id="ub694da54">我们结合 String 的源代码(jdk8)来看一下 jdk 是如何处理这个问题的，下面是源码的截图</span></p>
  <p data-lake-id="u4771f50e" id="u4771f50e"><br></p>
  <p data-lake-id="u5086c6d1" id="u5086c6d1"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331165958.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_20%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="ub265ab74" id="ub265ab74"><br></p>
  <p data-lake-id="uaaa458c8" id="uaaa458c8"><span data-lake-id="u4d8ee452" id="u4d8ee452">它实际上是重新定义了一个新的 buf[] 来保存数据，这样在最后返回数据的时候确实确没有修改 原始的value[]，而是将替换后的字符串作为返回值返回了。</span></p>
  <p data-lake-id="u6e984136" id="u6e984136"><br></p>
  <p data-lake-id="uacc34e74" id="uacc34e74"><span data-lake-id="udcd6ce08" id="udcd6ce08">通过分析 String 的实现，你可能已经发现了，如果具备不可变性的类，需要提供类似修改的功能，具体该怎么操作呢？做法很简单，那就是创建一个新的不可变对象，这是与可变对象的一个重要区别，可变对象往往是修改自己的属性。</span></p>
  <p data-lake-id="u7d0f921d" id="u7d0f921d"><br></p>
  <p data-lake-id="u2cdf5342" id="u2cdf5342"><span data-lake-id="uc7e0cc07" id="uc7e0cc07">所有的修改操作都创建一个新的不可变对象。但是一个问题的解决必然会带来的新的问题，那就是这样势必在每次使用的时候都会创建新的对象，那岂不是无端的降低了系统的性能了浪费了系统的资源？这个时候享元模式就可以大显神通了。</span></p>
  <p data-lake-id="uac781da3" id="uac781da3"><br></p>
  <h2 data-lake-id="e62a467c" id="e62a467c"><span data-lake-id="u4fc88217" id="u4fc88217">享元模式避免创建重复对象</span></h2>
  <p data-lake-id="uc84828ae" id="uc84828ae"><br></p>
  <p data-lake-id="u08cd1222" id="u08cd1222"><span data-lake-id="ue40242ea" id="ue40242ea">享元模式你可能实际开发中使用的很少，它是这么定义的：</span></p>
  <p data-lake-id="uc7c28e4f" id="uc7c28e4f"><br></p>
  <p data-lake-id="ue12c9f7b" id="ue12c9f7b"><span data-lake-id="u0c36aa83" id="u0c36aa83">享元模式（Flyweight Pattern）：是一种软件设计模式。它使用共享物件，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件；它适合用于只是因重复而导致使用无法令人接受的大量内存的大量物件。</span></p>
  <p data-lake-id="u646dc8c3" id="u646dc8c3"><br></p>
  <p data-lake-id="u164a4ff2" id="u164a4ff2"><span data-lake-id="u93e67fa5" id="u93e67fa5">通常物件中的部分状态是可以分享。常见做法是把它们放在外部数据结构，当需要使用时再将它们传递给享元</span></p>
  <p data-lake-id="ub5005b9b" id="ub5005b9b"><br></p>
  <p data-lake-id="u9a6a47e9" id="u9a6a47e9"><span data-lake-id="u780409b5" id="u780409b5">看不懂没关系，用一句直白话来概括就是：通过对象池的技术来避免重复的创建对象。这就好比是 Spring 中的容器（单例模式下），我们的对象都交给 Spring 容器来管理，这样我们再使用的时候只需要到容器中去拿即可，而不是每次都去创建新的对象。</span></p>
  <p data-lake-id="u38f05c8a" id="u38f05c8a"><br></p>
  <p data-lake-id="u52bb81c6" id="u52bb81c6"><span data-lake-id="uf1166202" id="uf1166202">利用享元模式可以减少创建对象的数量，从而减少内存占用。Java 语言里面 </span><code data-lake-id="udb396d90" id="udb396d90"><span data-lake-id="ua56d5f46" id="ua56d5f46">Long、Integer、Short、Byte</span></code><span data-lake-id="u48f4c38c" id="u48f4c38c"> 等这些基本数据类型的包装类都用到了享元模式。</span></p>
  <p data-lake-id="ufce04150" id="ufce04150"><br></p>
  <p data-lake-id="ud678953a" id="ud678953a"><strong><span data-lake-id="u5f3a4e4f" id="u5f3a4e4f">享元模式本质上其实就是一个对象池</span></strong><span data-lake-id="ud2718c3f" id="ud2718c3f">，利用享元模式创建对象的逻辑也很简单：</span><strong><span data-lake-id="u76c29b81" id="u76c29b81">创建之前，首先去对象池里看看是不是存在；如果已经存在，就利用对象池里的对象；如果不存在，就会新创建一个对象，并且把这个新创建出来的对象放进对象池里</span></strong><span data-lake-id="ud0dfba13" id="ud0dfba13">。</span></p>
  <p data-lake-id="u620080b1" id="u620080b1"><br></p>
  <p data-lake-id="uf4183374" id="uf4183374"><span data-lake-id="u56ba3591" id="u56ba3591">jdk 源码中是如何使用享元模式的呢？我们以 Long 这个类为例来解释说明下。</span></p>
  <p data-lake-id="uafa7b704" id="uafa7b704"><br></p>
  <p data-lake-id="u80a9c232" id="u80a9c232"><span data-lake-id="ud2f86bfd" id="ud2f86bfd">Long 这个类并没有照搬享元模式，Long 内部维护了一个静态的对象池，仅缓存了[-128,127]之间的数字，这个对象池在 JVM 启动的时候就创建好了，而且这个对象池一直都不会变化，也就是说它是静态的。之所以采用这样的设计，是因为 Long 这个对象的状态共有 2^64 种，实在太多，不宜全部缓存，而[-128,127]之间的数字利用率最高。</span></p>
  <p data-lake-id="uecd9f1b4" id="uecd9f1b4"><br></p>
  <p data-lake-id="ud9f192b8" id="ud9f192b8"><span data-lake-id="u84432f78" id="u84432f78">下面的示例代码出自 Java 1.8，valueOf() 方法就用到了 LongCache 这个缓存，你可以结合着来加深理解。</span></p>
  <p data-lake-id="ucb4131fe" id="ucb4131fe"><br></p>
  <p data-lake-id="u5639ecd5" id="u5639ecd5"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331170927.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_19%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="uc2aba65f" id="uc2aba65f"><br></p>
  <p data-lake-id="u170ea4ff" id="u170ea4ff"><span data-lake-id="ud1b3b19d" id="ud1b3b19d">在看下 LongCache 中的 cache 方法（关键地方都在图片的注释中了）</span></p>
  <p data-lake-id="ud8f34f51" id="ud8f34f51"><br></p>
  <p data-lake-id="u699be9a4" id="u699be9a4"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331171059.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_20%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="u93ebeecc" id="u93ebeecc"><br></p>
  <h2 data-lake-id="73b7662d" id="73b7662d"><span data-lake-id="u3e638ab1" id="u3e638ab1">基本类型包装类作为锁对象</span></h2>
  <p data-lake-id="ua19dd00c" id="ua19dd00c"><br></p>
  <p data-lake-id="u92ecc215" id="u92ecc215"><span data-lake-id="ud2b2f91c" id="ud2b2f91c">正是由于这些包装类内部用了享元模式，所以基本上所有的基础类型的包装类都不适合做锁，因为它们内部用到了享元模式，这会导致看上去私有的锁，其实是共有的。看下下面的代码，我们假设以 Long 对象作为锁，</span></p>
  <p data-lake-id="u063905de" id="u063905de"><br></p>
  <pre lang="java"><code>
class A {
    //定义一个 A 对象名字叫 aObj ,值为 1
    private Long aObj = Long.valueOf(1);
    //定义一个 B 对象名字叫 bObj，值为 1
    private Long bObj = Long.valueOf(1);

    private void a() {
        //锁对象是 aObj
        synchronized (aObj) {
            System.out.println("正在执行A方法，5秒以后退出");
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println("A执行结束......");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void b() {
        //锁对象是 bObj
        synchronized (bObj) {
            System.out.println("正在执行B方法，2秒以后退出");
            try {
                TimeUnit.SECONDS.sleep(2);
                System.out.println("B执行结束......");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        A a = new A();
        //开通两个线程来执行，因为aObj 和 bObj 是不同的对象，所以理论上应该是互不干扰的
        new Thread(a::a).start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(a::b).start();
    }
}
</code></pre>
  <p data-lake-id="u8c1334e5" id="u8c1334e5"><br></p>
  <p data-lake-id="ub31da7d2" id="ub31da7d2"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331173101.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_11%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="u9442a510" id="u9442a510"><br></p>
  <p data-lake-id="u273f62fe" id="u273f62fe"><span data-lake-id="uf5f3f4b8" id="uf5f3f4b8">但是却出现了上面这样的结果？为什么会是同步的执行呢？就是因为享元模式导致的，因为 1 是在 [-128~127] 的，所以定义再多的对象都是直接从缓存池中拿的，并不会创建新的对象，</span><strong><span data-lake-id="u5c84a9a2" id="u5c84a9a2">即锁的是同一个对象</span></strong><span data-lake-id="ued204c80" id="ued204c80">。现在改成一个不在 [-128~127] 范围之内的，假设是128</span></p>
  <p data-lake-id="u0db04823" id="u0db04823"><br></p>
  <p data-lake-id="ue00a2b31" id="ue00a2b31"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331173305.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_13%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="ucb0a66e2" id="ucb0a66e2"><br></p>
  <p data-lake-id="u80f6ec90" id="u80f6ec90"><span data-lake-id="ub584c2e4" id="ub584c2e4">结果为：</span></p>
  <p data-lake-id="u94b93ee9" id="u94b93ee9"><br></p>
  <p data-lake-id="u8f1f1205" id="u8f1f1205"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331173314.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_16%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="u00e95d0a" id="u00e95d0a"><br></p>
  <p data-lake-id="uc00ad2d1" id="uc00ad2d1"><span data-lake-id="uce2a48f3" id="uce2a48f3">这个时候发现两个是互不干扰的，也就是</span><strong><span data-lake-id="u90715666" id="u90715666">两个锁并不是同一个对象</span></strong><span data-lake-id="u07b199b2" id="u07b199b2">。</span></p>
  <p data-lake-id="u2df15d85" id="u2df15d85"><br></p>
  <h2 data-lake-id="3fdade20" id="3fdade20"><span data-lake-id="ucc36d132" id="ucc36d132">使用 Immutability 模式的注意事项</span></h2>
  <p data-lake-id="uc5ffaac2" id="uc5ffaac2"><br></p>
  <p data-lake-id="uac720eb9" id="uac720eb9"><span data-lake-id="u2b37ac7e" id="u2b37ac7e">在使用 Immutability 模式的时候，需要注意以下两点：</span></p>
  <p data-lake-id="u2d749107" id="u2d749107"><br></p>
  <ol list="uf3c7d76c">
   <li fid="udc244ad6" data-lake-id="u076d9d96" id="u076d9d96"><span data-lake-id="ue1c39fcf" id="ue1c39fcf">对象的所有属性都是 final 的，并不能保证不可变性；</span></li>
   <li fid="udc244ad6" data-lake-id="ucbd05a9c" id="ucbd05a9c"><span data-lake-id="u3a09f9c9" id="u3a09f9c9">不可变对象也需要正确发布。</span></li>
  </ol>
  <p data-lake-id="ua644cb77" id="ua644cb77"><br></p>
  <p data-lake-id="u43ee288e" id="u43ee288e"><span data-lake-id="ua4b561b6" id="ua4b561b6">在 Java 语言中，final 修饰的属性一旦被赋值，就不可以再修改，但是如果属性的类型是普通对象，那么这个普通对象的属性是可以被修改的。什么鬼？乱七八糟的。别急，我们来看个例子（毕竟光说含义就是等于在耍流氓）。</span></p>
  <p data-lake-id="u74767519" id="u74767519"><br></p>
  <pre lang="java"><code>
class D {
    final C c;

    public D(C c) {
        this.c = c;
    }

    private void changeValue(int salary) {
        c.setSalary(salary);
    }

    public static void main(String[] args) {
        C c = new C();
        c.setSalary(1);
        System.out.println("c.getSalary() = " + c.getSalary());
        D d = new D(c);
        d.changeValue(3);
        System.out.println("c.getSalary() = " + c.getSalary());
    }
}
</code></pre>
  <p data-lake-id="uef524d1a" id="uef524d1a"><br></p>
  <p data-lake-id="u61017ef5" id="u61017ef5"><img src="https://blogs-1302490380.cos.ap-nanjing.myqcloud.com/20210331174225.png?x-oss-process=image%2Fwatermark%2Ctype_d3F5LW1pY3JvaGVp%2Csize_11%2Ctext_SmF2YSA4IEd1IFA%3D%2Ccolor_FFFFFF%2Cshadow_50%2Ct_80%2Cg_se%2Cx_10%2Cy_10"></p>
  <p data-lake-id="ucebeb382" id="ucebeb382"><br></p>
  <p data-lake-id="uf9058337" id="uf9058337"><strong><span data-lake-id="ubb2c5fc4" id="ubb2c5fc4">在使用 Immutability 模式的时候一定要确认保持不变性的边界在哪里，是否要求属性对象也具备不可变性</span></strong><span data-lake-id="ub29d1fd3" id="ub29d1fd3">。这里的C对象是不可变的，但是里面的属性却是可以修改的。如果想要属性也不可以被修改，那么属性也必须要定义为 final 的。像这样的临界问题在处理的时候一定要加倍小心。</span></p>
  <p data-lake-id="u99294357" id="u99294357"><br></p>
  <h2 data-lake-id="9019b3d7" id="9019b3d7"><span data-lake-id="ud6640222" id="ud6640222">本文小结</span></h2>
  <p data-lake-id="u017868e5" id="u017868e5"><br></p>
  <p data-lake-id="ub13763df" id="ub13763df"><span data-lake-id="u0a0434b5" id="u0a0434b5">利用 Immutability 模式解决并发问题，也许你觉得有点陌生，其实你天天都在享受它的战果。Java 语言里面的 String 和 Long、Integer、Double 等基础类型的包装类都具备不可变性，这些对象的线程安全性都是靠不可变性来保证的。Immutability 模式是最简单的解决并发问题的方法，建议当你试图解决一个并发问题时，可以首先尝试一下 Immutability 模式，看是否能够快速解决。</span></p>
  <p data-lake-id="u95eec37c" id="u95eec37c"><br></p>
  <p data-lake-id="u43514735" id="u43514735"><span data-lake-id="ua105285c" id="ua105285c">具备不变性的对象，只有一种状态，这个状态由对象内部所有的不变属性共同决定。其实还有一种更简单的不变性对象，那就是无状态。无状态对象内部没有属性，只有方法。除了无状态的对象，你可能还听说过无状态的服务、无状态的协议等等。无状态有很多好处，最核心的一点就是性能。在多线程领域，无状态对象没有线程安全问题，无需同步处理，自然性能很好；在分布式领域，无状态意味着可以无限地水平扩展，所以分布式领域里面性能的瓶颈一定不是出在无状态的服务节点上。</span></p>
 </body>
</html>